/* 
 * File:   Reserve.h
 * Author: yurisvb
 * Trash code that may eventually be usefuls
 * Created on July 3, 2012, 2:26 PM
 */

#ifndef RESERVE_H
#define	RESERVE_H

    //    Tauint(bool sd = true) {
    //        if (sd) {
    //            //YSVB_SHOW(sd)
    //            set_data_0();
    //            //YSVB_SHOW(this->getBinaryDataString())
    //        }
    //    }
    //

//    Tauint smallTauint(const T & target) {
//        set_data_0();
//        m_data[0] = target;
//    }

    //    void operator=(const Tauint & target) {
    //        for (int i = 0; i < size; i++) {
    //            m_data[i] = target[i];
    //        }
    //    }

    //    Tauint(const Tauint & ti) {
    //        for (int i = 0; i < size; i++) {
    //            m_data[i] = ti.m_data[i];
    //        }
    //    }

    //    void operator=(const Tauint & target) {
    //        for (int i = 0; i < size; i++) {
    //            m_data[i] = target[i];
    //        }
    //    }

    //    Tauint(const Tauint & target) {
    //        this->operator=(target);
    //        VB_SHOW(Tauint::getBinaryDataString())
    //    }

    //    Tauint(const char* str, int base = 2) {
    //        //        std::cout << "Tauint(const char* str, unsigned base = 10)" << std::endl;
    //        //        YSVB_ASSERT_PLUS(base,==,2)
    //        //        YSVB_ASSERT_PLUS(base,==,10)
    //        //        YSVB_ASSERT_PLUS(base,==,3)
    //        if (base == 2) {
    //            //            YSVB_SHOW(str)
    //            setBinaryDataFromString(str);
    //            //            YSVB_ASSERT_PLUS(this->getBinaryDataString(),==,str)
    //            //            YSVB_ASSERT_PLUS(this->getBinaryDataString(),==,"1")
    //        } else {
    //            std::cout << "Fatal error" << std::endl;
    //        }
    //    }

    //    Tauint(T t) {
    //        if (t < 0) {
    //            std::cout << "WARNING: t = " << t << " < 0 " << std::endl << "Converted to -t = " << -t << std::endl;
    //            t = -t;
    //        }
    //        set_data_0();
    //        m_data[0] = t;
    //    }

    //    Tauint operator << (unsigned shift) const {
    //        Tauint ret(true);
    //        const unsigned  block(shift/sub_int_bit_size), 
    //                        //comp_block(size-block),
    //                        inner(shift%sub_int_bit_size),
    //                        comp_inner(sub_int_bit_size-inner);
    //        YSVB_SHOW(block)
    //        YSVB_SHOW(inner)
    //        YSVB_SHOW(comp_inner)
    //        int i(0), j;//loop handlers
    //        T Rmask, Wmask;
    ////        for (i = 0; i < block; i++) {
    ////            ret(i) = 0;
    ////        }
    ////        YSVB_ASSERT_PLUS(i,==,block)
    ////        ret(i) = 0;//fill bits of ret(i) with 0s.
    //        
    //        YSVB_SHOW(ret.getBinaryDataString());
    //        for (j = inner, Rmask = (T) 1, Wmask = (1<<inner); j < sub_int_bit_size; j++, Rmask *= 2, Wmask *= 2) {
    //            YSVB_ASSERT_PLUS(i,==,0)
    //            YSVB_SHOW(j)
    //            YSVB_SHOW((int) Wmask)
    //            YSVB_SHOW(((bool) m_data[i]&Rmask))
    //            if (m_data[i]&Rmask) {//set jth bit of ret(i) to 1
    //                YSVB_SHOW(ret[i])
    //                ret(i) = ret(i) | Wmask;
    //                YSVB_SHOW(ret[i])
    //            } else {//set jth bit of ret(i) to 0
    //                YSVB_SHOW(ret[i])
    //                ret(i) = ret(i) & ~Wmask;
    //                YSVB_SHOW(ret[i])
    //            }
    //        }
    //        YSVB_SHOW(ret.getBinaryDataString())
    //        YSVB_ASSERT_PLUS(i,<,size)
    //        for (i++; i < size; i++) {
    //            YSVB_ASSERT_PLUS(i,==,1)
    //            YSVB_SHOW(ret.getBinaryDataString());
    //            YSVB_ASSERT_PLUS(Rmask,==,((comp_inner==sub_int_bit_size)?(0):((T) 1 << comp_inner)))
    //            YSVB_ASSERT_PLUS(Wmask,==,0)//At this point, all bits were swapped
    //            for (j = 0, Wmask = (1); j < inner; j++, Rmask *= 2, Wmask *= 2) {
    //                YSVB_SHOW(i)
    //                YSVB_SHOW(j)
    //                YSVB_SHOW((int) Wmask)
    //                YSVB_SHOW(((bool) m_data[i]&Rmask))
    //                if (m_data[i]&Rmask) {//set jth bit of ret(i) to 1
    //                    YSVB_SHOW(ret[i])
    //                    ret(i) = ret(i) | Wmask;
    //                    YSVB_SHOW(ret[i])
    //                } else {//set jth bit of ret(i) to 0
    //                    YSVB_SHOW(ret[i])
    //                    ret(i) = ret(i) & ~Wmask;
    //                    YSVB_SHOW(ret[i])
    //                }
    //            }
    //            YSVB_SHOW(ret.getBinaryDataString());
    //            YSVB_ASSERT_PLUS(j,==,inner)
    //            YSVB_ASSERT_PLUS(Rmask,==,0)
    //            YSVB_ASSERT_PLUS(Wmask,==,(1 << inner))
    //            for (/*j = 0, */Rmask = (1); j < sub_int_bit_size; j++, Rmask *= 2, Wmask *= 2) {
    //                YSVB_SHOW(i)
    //                YSVB_SHOW(j)
    //                YSVB_SHOW((int) Wmask)
    //                YSVB_SHOW((int) Rmask)
    //                YSVB_SHOW((int) m_data[i])
    //                YSVB_SHOW((int) m_data[i-1])
    //                YSVB_SHOW(((bool) m_data[i]&Rmask))
    //                if (m_data[i]&Rmask) {//set jth bit of ret(i) to 1
    //                    YSVB_SHOW(ret[i])
    //                    ret(i) = ret(i) | Wmask;
    //                    YSVB_SHOW(ret[i])
    //                } else {//set jth bit of ret(i) to 0
    //                    YSVB_SHOW(ret[i])
    //                    ret(i) = ret(i) & ~Wmask;
    //                    YSVB_SHOW(ret[i])
    //                }
    //            }
    //            YSVB_SHOW(ret.getBinaryDataString());
    //        }
    //        YSVB_ASSERT_PLUS(Rmask,==,((comp_inner==sub_int_bit_size)?(0):((T) 1 << comp_inner)))
    //        YSVB_ASSERT_PLUS(Wmask,==,0)
    ////        for (j = 0, Wmask = (1); i < inner; j++, Rmask *= 2, Wmask *= 2) {
    ////            if (ret(i)&Rmask) {//set jth bit of ret(i) to 1
    ////                ret(i) |= Wmask;
    ////            } else {//set jth bit of ret(i) to 0
    ////                ret(i) &= ~Wmask;
    ////            }
    ////        }
    ////        YSVB_ASSERT(Rmask,==,0)
    ////        YSVB_ASSERT(Wmask,==,(1 << comp_inner))
    ////        YSVB_SHOW(ret.getBinaryDataString())
    //        return ret;
    //    }

//    Tauint MULT_P(const Tauint & target) const {
//        //YSVB_SHOW(linha++)
//        Tauint ret(false);
//        T bit_holder(0);
//        int i, j, k, l, li;
//        T mK, mJ; //masks for loop on k and j
//        for (i = 0; i < size; i++) {
//            for (j = 0; j < sub_int_bit_size; j++) {
//                for (k = 0, li = i - 1; k < i; k++) {
//                    for (l = 0, mK = 1, mJ = 1 << j;
//                            l < sub_int_bit_size;
//                            l++, mK << 1) {
//                        if ((m_data[i] & mK) && (target.m_data[li] & mJ)) {
//                            bit_holder++;
//                        }
//                        if (mJ != 1) {
//                            mJ = mJ >> 1;
//                        } else {
//                            li--;
//                            mJ = m_lastBit();
//                        }
//                    }
//                }
//                for (l = 0, mK = 1, mJ = 1 << j; l < j; l++, mK << 1, mJ >> 1) {
//                    if ((m_data[i] & mK) && (target.m_data[li] & mJ)) {
//                        bit_holder++;
//                    }
//                }
//                ret.m_data[i] |= (bit_holder & 1) << j;
//                YSVB_SHOW(i)
//                YSVB_SHOW(j)
//                YSVB_SHOW(mK)
//                YSVB_SHOW(mJ)
//                YSVB_SHOW(bit_holder)
//                bit_holder >> 1;
//            }
//        }
//        return ret;
//
//        //        for (i = 0; i < size; i++) {
//        //            for (j = 0; j < sub_int_bit_size; j++) {
//        //                Nk = i*sub_int_bit_size+j;
//        //                for (k = 0; k < Nk; k++) {
//        //                    if (this->m_data[i]) {
//        //                        bit_holder++;
//        //                    }
//        //                }
//        //            }
//        //        }
//    }

        ////        VB_SHOW("Shifting:")
        ////        myTauInt = Tauint("1") - Tauint("1");
        ////        myTauInt = myTauInt << 1;
        ////        YSVB_ASSERT_TEST(myTauInt.getBinaryDataString(),==,"0");
        //        myTauInt = (T) 1;
        ////        myTauInt = myTauInt << 1;
        ////        YSVB_ASSERT_TEST(myTauInt.getBinaryDataString(),==,"10");
        ////        myTauInt = myTauInt << 2;
        ////        YSVB_ASSERT_TEST(myTauInt.getBinaryDataString(),==,"1000");
        ////        myTauInt = myTauInt + Tauint((T)16);
        ////        YSVB_ASSERT_TEST(myTauInt.getBinaryDataString(),==,"11000");
        ////        myTauInt = myTauInt << 11;
        ////        YSVB_ASSERT_TEST(myTauInt.getBinaryDataString(),==,"1100000000000000");
        //        myTauInt = myTauInt << 16;
        //YSVB_ASSERT_TEST(myTauInt.getBinaryDataString(),==,"10000000000000000");

//        for (i = 0; i < block; i++) {
//            ret(i) = 0;
//        }
//        YSVB_ASSERT_PLUS(i,==,block)
//        ret(i) = 0;//fill bits of ret(i) with 0s.

//        for (j = 0, Wmask = (1); i < inner; j++, Rmask *= 2, Wmask *= 2) {
//            if (ret(i)&Rmask) {//set jth bit of ret(i) to 1
//                ret(i) |= Wmask;
//            } else {//set jth bit of ret(i) to 0
//                ret(i) &= ~Wmask;
//            }
//        }
//        YSVB_ASSERT(Rmask,==,0)
//        YSVB_ASSERT(Wmask,==,(1 << comp_inner))
//        YSVB_SHOW(ret.getBinaryDataString())


#endif	/* RESERVE_H */

